package org.jeecg.modules.flowable.common.util.validation;

import org.apache.commons.lang3.StringUtils;

import java.util.*;

/**
 * @Desc: 验证工具类
 * @Author  zxd
 * @Date   2020-01-31 11:20
 */
public class AssertValid {

    private static final String mobile = "^(13|15|18|17|16)[0-9]{9}$";

    private static final String codeAndMobile = "^\\+[0-9]{2}\\-(13|15|18|17|16)[0-9]{9}$";

    /**整数*/
    private static final String intege="^-?[1-9]\\d*$";
    /** 正整数*/
    private static final String intege1="^[1-9]\\d*$";
    /** 负整数*/
    private static final String intege2="^-[1-9]\\d*$";
    /** 数字*/
    private static final String num="^([+-]?)\\d*\\.?\\d+$";
    /** 正数（正整数 + 0）*/
    private static final String num1="^[1-9]\\d*|0$";
    /** 负数（负整数 + 0）*/
    private static final String num2="^-[1-9]\\d*|0$";
    /** 浮点数*/
    private static final String decmal="^([+-]?)\\d*\\.\\d+$";
    /** 正浮点数*/
    private static final String decmal1="^[1-9]\\d*.\\d*|0.\\d*[1-9]\\d*$";
    /** 负浮点数*/
    private static final String decmal2="^-([1-9]\\d*.\\d*|0.\\d*[1-9]\\d*)$";
    /** 浮点数*/
    private static final String decmal3="^-?([1-9]\\d*.\\d*|0.\\d*[1-9]\\d*|0?.0+|0)$";
    /** 非负浮点数（正浮点数 + 0）*/
    private static final String decmal4="^[1-9]\\d*.\\d*|0.\\d*[1-9]\\d*|0?.0+|0$";
    /**非正浮点数（负浮点数 + 0） */
    private static final String decmal5="^(-([1-9]\\d*.\\d*|0.\\d*[1-9]\\d*))|0?.0+|0$";
    /** 邮件*/
    private static final String email="^\\w+((-\\w+)|(\\.\\w+))*\\@[A-Za-z0-9]+((\\.|-)[A-Za-z0-9]+)*\\.[A-Za-z0-9]+$";
    /** 颜色*/
    private static final String color="^[a-fA-F0-9]{6}$";
    /** url*/
    private static final String url="^http[s]?=\\/\\/([\\w-]+\\.)+[\\w-]+([\\w-./?%&amp;=]*)?$";
    /** 仅中文*/
    private static final String chinese="^[\\u4E00-\\u9FA5\\uF900-\\uFA2D]+$";
    /** 仅ACSII字符*/
    private static final String ascii="^[\\x00-\\xFF]+$";
    /**邮编 */
    private static final String zipcode="^\\d{6}$";
    /** ip地址*/
    private static final String ip4="^(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)\\.(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)\\.(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)\\.(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)$";
    /** 非空*/
    private static final String notempty="^\\S+$";
    /**图片 */
    private static final String picture="(.*)\\.(jpg|bmp|gif|ico|pcx|jpeg|tif|png|raw|tga)$";
    /** 压缩文件*/
    private static final String rar="(.*)\\.(rar|zip|7zip|tgz)$";
    /** 日期*/
    private static final String date="^\\d{4}(\\-|\\/|\\.)\\d{1,2}\\1\\d{1,2}$";
    /** QQ号码*/
    private static final String qq="^[1-9]*[1-9][0-9]*$";
    /** 电话号码的函数(包括验证国内区号;国际区号;分机号)*/
    private static final String tel="^(([0\\+]\\d{2,3}-)?(0\\d{2,3})-)?(\\d{7,8})(-(\\d{1,}))?$";
    /** 用来用户注册。匹配由数字、26个英文字母或者下划线组成的字符串*/
    private static final String username="^\\w+$";
    /** 字母*/
    private static final String letter="^[A-Za-z]+$";
    private static final String letterAndSpace="^[A-Za-z ]+$";
    /** 大写字母*/
    private static final String letter_u="^[A-Z]+$";
    /** 小写字母*/
    private static final String letter_l="^[a-z]+$";
    /** 身份证*/
    private static final String idcard="^[1-9]\\d{5}(18|19|20|(3\\d))\\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]$";
    /**判断字符串是否为浮点数*/
    private static final String isFloat="^[-]?\\d+(\\.\\d+)?$";
    /**判断字符串是否为正浮点数*/
    private static final String isUFloat="^\\d+(\\.\\d+)?$";
    /**判断是否是整数*/
    private static final String isInteger="^[-]?\\d+$";
    /**判断是否是正整数*/
    private static final String isUInteger="^\\d+$";
    /**判断车辆Vin码*/
    private static final String isCarVin="^[1234567890WERTYUPASDFGHJKLZXCVBNM]{13}[0-9]{4}$";
    /** 手机号 */
    public static boolean isMobile(String input){
        return matches(mobile, input);
    }
    public static boolean isCodeAndMobile(String input){
        return matches(codeAndMobile, input);
    }
    /** 整数 */
    public static boolean isIntege(String input){
        return matches(intege, input);
    }
    /** 正整数 */
    public static boolean isintege1(String input){
        return matches(intege1, input);
    }
    /** 负整数*/
    public static boolean isIntege2(String input){
        return matches(intege2, input);
    }
    /** 数字 */
    public static boolean isNum(String input){
        return matches(num, input);
    }
    /** 正数（正整数 + 0） */
    public static boolean isNum1(String input){
        return matches(num1, input);
    }
    /** 负数（负整数 + 0）*/
    public static boolean isNum2(String input){
        return matches(num2, input);
    }
    /** 浮点数*/
    public static boolean isDecmal(String input){
        return matches(decmal, input);
    }
    /** 正浮点数*/
    public static boolean isDecmal1(String input){
        return matches(decmal1, input);
    }
    /** 负浮点数*/
    public static boolean isDecmal2(String input){
        return matches(decmal2, input);
    }
    /**浮点数 */
    public static boolean isDecmal3(String input){
        return matches(decmal3, input);
    }
    /** 非负浮点数（正浮点数 + 0）*/
    public static boolean isDecmal4(String input){
        return matches(decmal4, input);
    }
    /** 非正浮点数（负浮点数 + 0）*/
    public static boolean isDecmal5(String input){
        return matches(decmal5, input);
    }
    /** 邮件*/
    public static boolean isEmail(String input){
        return matches(email, input);
    }
    /** 颜色*/
    public static boolean isColor(String input){
        return matches(color, input);
    }
    /** url*/
    public static boolean isUrl(String input){
        return matches(url, input);
    }
    /** 中文*/
    public static boolean isChinese(String input){
        return matches(chinese, input);
    }
    /** ascii码*/
    public static boolean isAscii(String input){
        return matches(ascii, input);
    }
    /** 邮编*/
    public static boolean isZipcode(String input){
        return matches(zipcode, input);
    }
    /** IP地址*/
    public static boolean isIP4(String input){
        return matches(ip4, input);
    }
    /** 图片*/
    public static boolean isPicture(String input){
        return matches(picture, input);
    }
    /** 压缩文件*/
    public static boolean isRar(String input){
        return matches(rar, input);
    }
    /** 日期*/
    public static boolean isDate(String input){
        return matches(date, input);
    }
    /** qq*/
    public static boolean isQQ(String input){
        return matches(qq, input);
    }
    /** 电话号码的函数(包括验证国内区号;国际区号;分机号)*/
    public static boolean isTel(String input){
        return matches(tel, input);
    }
    /** 用来用户注册。匹配由数字、26个英文字母或者下划线组成的字符串*/
    public static boolean isUserName(String input){
        return matches(username, input);
    }
    /**字母*/
    public static boolean isLetter(String input){
        return matches(letter, input);
    }
    public static boolean isLetterAndSpace(String input){
        return matches(letterAndSpace, input);
    }
    /** 小写字母*/
    public static boolean isLowLetter(String input){
        return matches(letter_l, input);
    }
    /** 大写字母*/
    public static boolean isUpperLetter(String input){
        return matches(letter_u, input);
    }
    /** 身份证*/
    public static boolean isIDCard(String input){
        return matches(idcard, input);
    }
    public static boolean isUFloat(String input){
        return matches(isUFloat, input);
    }
    public static boolean isInteger(String input){
        return matches(isInteger, input);
    }
    public static boolean isUInteger(String input){
        return matches(isUInteger, input);
    }

    public static boolean isCarVin(String carVin){
        return matches(isCarVin, carVin);
    }

    public static boolean matches(String regex,String input){
        if(StringUtils.isBlank(input)) return false;
        if(input.matches(regex))return true;
        return false;
    }

    /**
     * 功能描述:
     * 〈判断数组是否为空〉
     *
     * @params : [obj]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 14:43
     */
    public static <T> boolean isEmpty(T[] obj) {
        return null == obj || 0 == obj.length;
    }

    /**
     * 功能描述:
     * 〈判断数组是否不为空〉
     *
     * @params : [obj]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 14:43
     */
    public static <T> boolean isNotEmpty(T[] obj) {
        return !isEmpty(obj);
    }

    /**
     * 功能描述:
     * 〈判断对象是否为空〉
     *
     * @params : [obj]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 14:44
     */
    public static boolean isEmpty(Object obj) {
        return null == obj;
    }

    /**
     * 功能描述:
     * 〈判断对象是否不为空〉
     *
     * @params : [obj]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 14:45
     */
    public static boolean isNotEmpty(Object obj) {
        return !isEmpty(obj);
    }

    /**
     * 功能描述:
     * 〈字符串是否为空〉
     *
     * @params : [str]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 14:48
     */
    public static boolean isEmpty(String str) {
        return null == str || "".equals(str.trim());
    }

    /**
     * 功能描述:
     * 〈字符串是否不为空〉
     *
     * @params : [str]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 14:48
     */
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    /**
     * 功能描述:
     * 〈判断集合是否为空〉
     *
     * @params : [obj]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 14:49
     */
    public static boolean isEmpty(Collection obj) {
        return null == obj || obj.isEmpty() || obj.size()==0;
    }

    /**
     * 功能描述:
     * 〈判断集合是否不为空〉
     *
     * @params : [obj]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 14:49
     */
    public static boolean isNotEmpty(Collection obj) {
        return !isEmpty(obj);
    }

    /**
     * 功能描述:
     * 〈判断map集合是否为空〉
     *
     * @params : [obj]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 14:50
     */
    public static boolean isEmpty(Map obj) {
        return null == obj || obj.isEmpty();
    }

    /**
     * 功能描述:
     * 〈判断map集合是否不为空〉
     *
     * @params : [obj]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 14:50
     */
    public static boolean isNotEmpty(Map obj) {
        return !isEmpty(obj);
    }

    /**
     * 功能描述:
     * 〈char数值是否是数字〉
     *
     * @params : [charValue]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 14:55
     */
    public static boolean charIsNumb(int charValue) {
        return charValue >= 48 && charValue <= 57 || charValue >= 96 && charValue <= 105;
    }

    /**
     * 功能描述:
     * 〈判断字符串是否是纯数字浮点类型〉
     *
     * @params : [s]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 14:57
     */
    public static boolean isFloat(String s) {
        if(!(s.indexOf(".") > -1)){
            return false;
        }
        char[] chars = s.toCharArray();
        boolean flag = true;
        for (char aChar : chars) {
            if(aChar != 46){
                if(!(aChar >= 48 && aChar <= 57 || aChar >= 96 && aChar <= 105)){
                    flag = false;
                    break;
                }
            }
        }
        return flag;
    }

    /**
     * 功能描述:
     * 〈非纯数字浮点类型〉
     *
     * @params : [s]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 15:15
     */
    public static boolean isNotFloat(String s) {
        return !isFloat(s);
    }
    /**
     * 功能描述:
     * 〈字符串是否是数字〉
     *
     * @params : [str]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 15:08
     */
    public static boolean isNumb(String str) {
        if (isEmpty((Object)str)) {
            return false;
        } else {
            char[] chr = str.toCharArray();

            for(int i = 0; i < chr.length; ++i) {
                if (chr[i] < '0' || chr[i] > '9') {
                    return false;
                }
            }

            return true;
        }
    }

    /**
     * 功能描述:
     * 〈判断字符串是否不是数字〉
     *
     * @params : [str]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 15:15
     */
    public static boolean isNotNumb(String str) {
        return !isNumb(str);
    }

    /**
     * 功能描述:
     * 〈判断字符串是否有长度,并自定义异常信息〉
     *
     * @params : [str, msg]
     * @return : void
     * @author : cwl
     * @date : 2019/10/17 15:09
     */
    public static void hasLength(String str, String msg) {
        if (str == null || str.length() < 1) {
            throw new RuntimeException(msg);
        }
    }

    /**
     * 功能描述:
     * 〈自定义参数校验异常〉
     *
     * @params : [msg, obj]
     * @return : void
     * @author : cwl
     * @date : 2019/10/17 15:24
     */
    public static void paramCheck(String msg,Object...obj) {
        for (Object o : obj) {
            // 参数异常
            if(isEmpty(o)){
                throw new RuntimeException(msg);
            }
        }
    }

    /**
     * 功能描述:
     * 〈可变参数,判断是否所有对象都为空〉
     *
     * @params : [obj]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 15:10
     */
    public static boolean isAllEmpty(Object... obj) {
        Object[] var1 = obj;
        int var2 = obj.length;

        for(int var3 = 0; var3 < var2; ++var3) {
            Object o = var1[var3];
            if (!isEmpty(o)) {
                return false;
            }
        }

        return true;
    }

    /**
     * 功能描述:
     * 〈可变参数-判断只要有任意一个对象为空,则为true〉
     *
     * @params : [obj]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 15:11
     */
    public static boolean isAnyEmpty(Object... obj) {
        Object[] var1 = obj;
        int var2 = obj.length;

        for(int var3 = 0; var3 < var2; ++var3) {
            Object o = var1[var3];
            if (isEmpty(o)) {
                return true;
            }
        }

        return false;
    }

    /**
     * 功能描述:
     * 〈可变参数 -判断是否所有参数都不为空〉
     *
     * @params : [obj]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 15:11
     */
    public static boolean isAllNotEmpty(Object... obj) {
        Object[] var1 = obj;
        int var2 = obj.length;

        for(int var3 = 0; var3 < var2; ++var3) {
            Object o = var1[var3];
            if (isEmpty(o)) {
                return false;
            }
        }

        return true;
    }

    /**
     * 功能描述:
     * 〈判断是否两个对象相等〉
     *
     * @params : [o1, o2]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 15:12
     */
    public static boolean isEqual(Object o1, Object o2) {
        if (o1 == null) {
            return o2 == null;
        } else if (o2 == null) {
            return false;
        } else if (o1.getClass().isArray()) {
            for(int i = 0; i < ((Object[])((Object[])o1)).length; ++i) {
                if (!isEqual(((Object[])((Object[])o1))[i], ((Object[])((Object[])o2))[i])) {
                    return false;
                }
            }

            return true;
        } else if (Collection.class.isAssignableFrom(o1.getClass())) {
            Iterator i1 = ((Collection)o1).iterator();
            Iterator i2 = ((Collection)o2).iterator();
            if (((Collection)o1).size() != ((Collection)o2).size()) {
                return false;
            } else {
                for(int i = 0; i < ((Collection)o1).size(); ++i) {
                    if (!isEqual(i1.next(), i2.next())) {
                        return false;
                    }
                }

                return true;
            }
        } else if (!Map.class.isAssignableFrom(o1.getClass())) {
            return o1.equals(o2);
        } else {
            Map<Object, Object> m1 = (Map)o1;
            Map<Object, Object> m2 = (Map)o2;
            if (m1.size() != m2.size()) {
                return false;
            } else if (!isEqual(m1.keySet(), m2.keySet())) {
                return false;
            } else {
                Iterator var4 = m1.entrySet().iterator();

                Map.Entry o;
                do {
                    if (!var4.hasNext()) {
                        return true;
                    }

                    o = (Map.Entry)var4.next();
                } while(m2.containsKey(o.getKey()) && isEqual(o.getValue(), m2.get(o.getKey())));

                return false;
            }
        }
    }

    /**
     * 功能描述:
     * 〈判断两个对象是否不相等〉
     *
     * @params : [o1, o2]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 15:13
     */
    public static boolean isNotEqual(Object o1, Object o2) {
        return !isEqual(o1,o2);
    }

    /**
     * 功能描述:
     * 〈比较两个集合是否相等〉
     *
     * @params : [l1, l2]
     * @return : boolean
     * @author : cwl
     * @date : 2019/10/17 14:46
     */
    public static boolean compare(List<Comparable> l1, List<Comparable> l2) {
        if (l1 != null && !l1.isEmpty()) {
            if (l2 != null && !l2.isEmpty()) {
                Collections.sort(l1);
                Collections.sort(l2);
                if (l1.size() != l2.size()) {
                    return false;
                } else {
                    for(int i = 0; i < l1.size(); ++i) {
                        if (((Comparable)l1.get(i)).compareTo(l2.get(i)) != 0) {
                            return false;
                        }
                    }

                    return true;
                }
            } else {
                return false;
            }
        } else {
            return l2 == null || l2.isEmpty();
        }
    }
}
